/*最近公共祖先(LCA)

* 1.向上标记法O(n)
    (1) 从x向上走到根节点，并标记所有经过的结点
    (2)从y向上走到根节点，当第一次遇到已经标记的结点时，就找到了LCA(x,y);

* 2.树上倍增法O((n+m)logn):预处理O(nlogn),每次查询(logn)
    核心数组fa[i][j]:表示从i结点开始，向上走2^j远的祖先结点, 0<=j<=logn
    (1)bfs得到每个结点所处的深度depth[]。根节点为1，越界结点fa[0]=0, depth[x]表示x的深度。
    (2)用二进制拆分，找到a的，b同深度的祖先。（假设a深度大于b）。
    (3)如果此时a==b，那么b是a祖先结点，此时a就是LCA(a,b);
    (4)如果此时a!=b,我们仍然二进制拆分，使得fa[a][i] == fa[b][i];
    (5)此时 a、b,是最近公共祖先的子节点。fa[a][0] == fa[b][0] == LCA(a,b);

* 注意点：
    (1)lca中的第一个for，目的是找到a的，和b同深度的祖先结点。一定要从大到小遍历。
    (2)lca中的第二个for，目的是让a和b分别转移到LCA(a,b)的子节点上，一定要从大到小遍历。
    (3)本题中lca第二个for从小到大遍历也能过，是因为没要求输出正确LCA(a,b),只要求判断。
    (4)第一for目的是让距离t变为0，第二个for目的是让t变为1。
    (5)我们只有从最高位1遍历，才能根据唯一的二进制形式达到要求。

*/

#pragma GCC optimize("O1,O2,O3,Ofast")
#pragma GCC optimize("no-stack-protector,unroll-loops,fast-math,inline")
#pragma GCC target("avx,avx2,fma")
#pragma GCC target("sse,sse2,sse3,sse4,sse4.1,sse4.2,ssse3")

#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
// #define ONLINE_GUDGE
using namespace std;
const int N = 1e5 + 10, M = N * 2, INF = 0x3f3f3f3f;

int n;
int e[M], ne[M], h[N], w[M], idx;
// bool st[N]; 
int depth[N], fa[N][16];


void AddEdge(int a, int b)//, int c)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ; // w[idx] = c;
}

bool bfs(int root)
{
    memset(depth, 0x3f, sizeof depth);

    depth[0] = 0; depth[root] = 1;
    queue<int> q; 
    q.push(root);
    // st[root] = true; // 放入队列 

    while(q.size())
    {
        auto u = q.front();q.pop();

        for(int i = h[u]; ~i; i = ne[i])
        {
            int v = e[i];
            // 每个节点只有一个父节点，只会初始化(访问)一次，在无向图中，只需特判不直接相连即可
            if(depth[v] > depth[u] + 1){ 
                depth[v] = depth[u] + 1;               
                q.push(v);
                fa[v][0] = u; // 往上走2^0=1，就是父节点
                for(int k = 1; k <= 15; k++)
                    fa[v][k] = fa[fa[v][k-1]][k-1]; // v向上走2^k的节点是v向上走2^(k-1) * 2^(k-1)的节点
                
            }
        }
    }
    return true;
}

int lca(int a, int b)
{
    // 默认a的深度深于b，方便之后操作
    if (depth[a] < depth[b]) swap(a, b);

    // 这一步是要找到 1.a的 2.和b在同一深度的 祖先。
    // 我们假设 t = depth[a] - depth[b]; 将t看成一个二进制数，可以不断地寻找t的最高位的1
    // t每次减去一个最高位的1的距离(2^i)，最终t就会为0，就找到了 1.a的 2.和b在同一深度的 祖先。
    // 注意，我们找的是最高位的1，所以从大到小遍历
    for (int k = 15; k >= 0; k--)
    {
        // 对深度进行判断，越界的深度都是0
        if (depth[fa[a][k]] >= depth[b])
            a = fa[a][k];
    }
    
    // 这里我们只是单纯的找到a的，和b在同一深度的祖先
    // 如果此时二者就相等了，那么说明b就是a的(最近公共)祖先
    if (a == b)
        return a;


    // 此时a，b同层，但是不同结点，二者距离最近公共祖先的长度是一样的, a,b此时一起向上走也是一样的
    // 如果 fa[a][i] != fa[b][i]，那么二者距离最近公共祖先的距离起码还有 2^i
    // 所以 a = fa[a][i], b = fa[b][i]
    for (int i = 20; i >= 0; i--)
    {
        if (fa[a][i] != fa[b][i])
        {
            a = fa[a][i];
            b = fa[b][i];
        }
    }
    // 此时f[a][0] == f[b][0]，a、b是最近公共祖先的子节点。
    return fa[a][0];
}

signed main()
{
    #ifdef ONLINE_JUDGE

    #else
    freopen("./in.txt","r",stdin);
    #endif
    ios::sync_with_stdio(false);   
	cin.tie(0);

    cin >> n;
    int root = 0;
    memset(h, -1, sizeof h);

    for(int i = 0; i < n; i++)
    {
        int a, b; cin >> a >> b;
        if(b == -1) root = a;
        else AddEdge(a, b), AddEdge(b, a);
    }

    bfs(root);

    int T; cin >> T;
    while(T--)
    {
        int a, b;  cin >> a >> b;
        int p = lca(a, b);
        if(p == a) printf("1\n");
        else if(p == b) printf("2\n");
        else printf("0\n");
    }
    
    return 0;
}